package com.taobao.txc.resourcemanager.b.c;

import com.taobao.txc.resourcemanager.b.c;
import java.io.InputStream;
import java.io.Reader;
import java.math.BigDecimal;
import java.net.URL;
import java.sql.Array;
import java.sql.Blob;
import java.sql.Clob;
import java.sql.Connection;
import java.sql.Date;
import java.sql.NClob;
import java.sql.ParameterMetaData;
import java.sql.Ref;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.RowId;
import java.sql.SQLWarning;
import java.sql.SQLXML;
import java.sql.Statement;
import java.sql.Time;
import java.sql.Timestamp;
import java.util.Calendar;
import java.util.Map;

public class b
  extends c
{
  public b(Statement paramStatement, com.taobao.txc.resourcemanager.b.a.a parama, String paramString)
  {
    super(paramStatement, parama, paramString);
  }
  
  public ResultSet executeQuery()
  {
    ResultSet localResultSet = null;
    try
    {
      localResultSet = super.executeQuery();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localResultSet;
  }
  
  public int executeUpdate()
  {
    int i = -1;
    try
    {
      i = super.executeUpdate();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return i;
  }
  
  public void setNull(int paramInt1, int paramInt2)
  {
    try
    {
      super.setNull(paramInt1, paramInt2);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setBoolean(int paramInt, boolean paramBoolean)
  {
    try
    {
      super.setBoolean(paramInt, paramBoolean);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setByte(int paramInt, byte paramByte)
  {
    try
    {
      super.setByte(paramInt, paramByte);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setShort(int paramInt, short paramShort)
  {
    try
    {
      super.setShort(paramInt, paramShort);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setInt(int paramInt1, int paramInt2)
  {
    try
    {
      super.setInt(paramInt1, paramInt2);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setLong(int paramInt, long paramLong)
  {
    try
    {
      super.setLong(paramInt, paramLong);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setFloat(int paramInt, float paramFloat)
  {
    try
    {
      super.setFloat(paramInt, paramFloat);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setDouble(int paramInt, double paramDouble)
  {
    try
    {
      super.setDouble(paramInt, paramDouble);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setBigDecimal(int paramInt, BigDecimal paramBigDecimal)
  {
    try
    {
      super.setBigDecimal(paramInt, paramBigDecimal);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setString(int paramInt, String paramString)
  {
    try
    {
      super.setString(paramInt, paramString);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setBytes(int paramInt, byte[] paramArrayOfByte)
  {
    try
    {
      super.setBytes(paramInt, paramArrayOfByte);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setDate(int paramInt, Date paramDate)
  {
    try
    {
      super.setDate(paramInt, paramDate);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setTime(int paramInt, Time paramTime)
  {
    try
    {
      super.setTime(paramInt, paramTime);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setTimestamp(int paramInt, Timestamp paramTimestamp)
  {
    try
    {
      super.setTimestamp(paramInt, paramTimestamp);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setAsciiStream(int paramInt1, InputStream paramInputStream, int paramInt2)
  {
    try
    {
      super.setAsciiStream(paramInt1, paramInputStream, paramInt2);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setUnicodeStream(int paramInt1, InputStream paramInputStream, int paramInt2)
  {
    try
    {
      super.setUnicodeStream(paramInt1, paramInputStream, paramInt2);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setBinaryStream(int paramInt1, InputStream paramInputStream, int paramInt2)
  {
    try
    {
      super.setBinaryStream(paramInt1, paramInputStream, paramInt2);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void clearParameters()
  {
    try
    {
      super.clearParameters();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setObject(int paramInt1, Object paramObject, int paramInt2)
  {
    try
    {
      super.setObject(paramInt1, paramObject, paramInt2);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setObject(int paramInt, Object paramObject)
  {
    try
    {
      super.setObject(paramInt, paramObject);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public boolean execute()
  {
    boolean bool = false;
    try
    {
      bool = super.execute();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return bool;
  }
  
  public void addBatch()
  {
    try
    {
      super.addBatch();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setCharacterStream(int paramInt1, Reader paramReader, int paramInt2)
  {
    try
    {
      super.setCharacterStream(paramInt1, paramReader, paramInt2);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setRef(int paramInt, Ref paramRef)
  {
    try
    {
      super.setRef(paramInt, paramRef);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setBlob(int paramInt, Blob paramBlob)
  {
    try
    {
      super.setBlob(paramInt, paramBlob);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setClob(int paramInt, Clob paramClob)
  {
    try
    {
      super.setClob(paramInt, paramClob);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setArray(int paramInt, Array paramArray)
  {
    try
    {
      super.setArray(paramInt, paramArray);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public ResultSetMetaData getMetaData()
  {
    ResultSetMetaData localResultSetMetaData = null;
    try
    {
      localResultSetMetaData = super.getMetaData();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localResultSetMetaData;
  }
  
  public void setDate(int paramInt, Date paramDate, Calendar paramCalendar)
  {
    try
    {
      super.setDate(paramInt, paramDate, paramCalendar);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setTime(int paramInt, Time paramTime, Calendar paramCalendar)
  {
    try
    {
      super.setTime(paramInt, paramTime, paramCalendar);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setTimestamp(int paramInt, Timestamp paramTimestamp, Calendar paramCalendar)
  {
    try
    {
      super.setTimestamp(paramInt, paramTimestamp, paramCalendar);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setNull(int paramInt1, int paramInt2, String paramString)
  {
    try
    {
      super.setNull(paramInt1, paramInt2, paramString);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setURL(int paramInt, URL paramURL)
  {
    try
    {
      super.setURL(paramInt, paramURL);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public ParameterMetaData getParameterMetaData()
  {
    ParameterMetaData localParameterMetaData = null;
    try
    {
      localParameterMetaData = super.getParameterMetaData();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localParameterMetaData;
  }
  
  public void setRowId(int paramInt, RowId paramRowId)
  {
    try
    {
      super.setRowId(paramInt, paramRowId);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setNString(int paramInt, String paramString)
  {
    try
    {
      super.setNString(paramInt, paramString);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setNCharacterStream(int paramInt, Reader paramReader, long paramLong)
  {
    try
    {
      super.setNCharacterStream(paramInt, paramReader, paramLong);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setNClob(int paramInt, NClob paramNClob)
  {
    try
    {
      super.setNClob(paramInt, paramNClob);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setClob(int paramInt, Reader paramReader, long paramLong)
  {
    try
    {
      super.setClob(paramInt, paramReader, paramLong);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setBlob(int paramInt, InputStream paramInputStream, long paramLong)
  {
    try
    {
      super.setBlob(paramInt, paramInputStream, paramLong);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setNClob(int paramInt, Reader paramReader, long paramLong)
  {
    try
    {
      super.setNClob(paramInt, paramReader, paramLong);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setSQLXML(int paramInt, SQLXML paramSQLXML)
  {
    try
    {
      super.setSQLXML(paramInt, paramSQLXML);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setObject(int paramInt1, Object paramObject, int paramInt2, int paramInt3)
  {
    try
    {
      super.setObject(paramInt1, paramObject, paramInt2, paramInt3);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setAsciiStream(int paramInt, InputStream paramInputStream, long paramLong)
  {
    try
    {
      super.setAsciiStream(paramInt, paramInputStream, paramLong);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setBinaryStream(int paramInt, InputStream paramInputStream, long paramLong)
  {
    try
    {
      super.setBinaryStream(paramInt, paramInputStream, paramLong);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setCharacterStream(int paramInt, Reader paramReader, long paramLong)
  {
    try
    {
      super.setCharacterStream(paramInt, paramReader, paramLong);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setAsciiStream(int paramInt, InputStream paramInputStream)
  {
    try
    {
      super.setAsciiStream(paramInt, paramInputStream);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setBinaryStream(int paramInt, InputStream paramInputStream)
  {
    try
    {
      super.setAsciiStream(paramInt, paramInputStream);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setCharacterStream(int paramInt, Reader paramReader)
  {
    try
    {
      super.setCharacterStream(paramInt, paramReader);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setNCharacterStream(int paramInt, Reader paramReader)
  {
    try
    {
      super.setNCharacterStream(paramInt, paramReader);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setClob(int paramInt, Reader paramReader)
  {
    try
    {
      super.setClob(paramInt, paramReader);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setBlob(int paramInt, InputStream paramInputStream)
  {
    try
    {
      super.setBlob(paramInt, paramInputStream);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setNClob(int paramInt, Reader paramReader)
  {
    try
    {
      super.setNClob(paramInt, paramReader);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public ResultSet executeQuery(String paramString)
  {
    ResultSet localResultSet = null;
    try
    {
      localResultSet = super.executeQuery(paramString);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localResultSet;
  }
  
  public int executeUpdate(String paramString)
  {
    int i = -1;
    try
    {
      i = super.executeUpdate(paramString);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return i;
  }
  
  public void close()
  {
    try
    {
      super.close();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public int getMaxFieldSize()
  {
    int i = -1;
    try
    {
      i = super.getMaxFieldSize();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return i;
  }
  
  public void setMaxFieldSize(int paramInt)
  {
    try
    {
      super.setMaxFieldSize(paramInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public int getMaxRows()
  {
    int i = -1;
    try
    {
      i = super.getMaxRows();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return i;
  }
  
  public void setMaxRows(int paramInt)
  {
    try
    {
      super.setMaxRows(paramInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setEscapeProcessing(boolean paramBoolean)
  {
    try
    {
      super.setEscapeProcessing(paramBoolean);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public int getQueryTimeout()
  {
    int i = -1;
    try
    {
      i = super.getQueryTimeout();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return i;
  }
  
  public void setQueryTimeout(int paramInt)
  {
    try
    {
      super.setQueryTimeout(paramInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void cancel()
  {
    try
    {
      super.cancel();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public SQLWarning getWarnings()
  {
    SQLWarning localSQLWarning = null;
    try
    {
      localSQLWarning = super.getWarnings();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localSQLWarning;
  }
  
  public void clearWarnings()
  {
    try
    {
      super.clearWarnings();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setCursorName(String paramString)
  {
    try
    {
      super.setCursorName(paramString);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public boolean execute(String paramString)
  {
    boolean bool = false;
    try
    {
      bool = super.execute(paramString);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return bool;
  }
  
  public ResultSet getResultSet()
  {
    ResultSet localResultSet = null;
    try
    {
      localResultSet = super.getResultSet();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localResultSet;
  }
  
  public int getUpdateCount()
  {
    int i = -1;
    try
    {
      i = super.getUpdateCount();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return i;
  }
  
  public boolean getMoreResults()
  {
    boolean bool = false;
    try
    {
      bool = super.getMoreResults();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return bool;
  }
  
  public void setFetchDirection(int paramInt)
  {
    try
    {
      super.setFetchDirection(paramInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public int getFetchDirection()
  {
    int i = -1;
    try
    {
      i = super.getFetchDirection();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return i;
  }
  
  public void setFetchSize(int paramInt)
  {
    try
    {
      super.setFetchSize(paramInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public int getFetchSize()
  {
    int i = -1;
    try
    {
      i = super.getFetchSize();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return i;
  }
  
  public int getResultSetConcurrency()
  {
    int i = -1;
    try
    {
      i = super.getResultSetConcurrency();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return i;
  }
  
  public int getResultSetType()
  {
    int i = -1;
    try
    {
      i = super.getResultSetType();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return i;
  }
  
  public void addBatch(String paramString)
  {
    try
    {
      super.addBatch(paramString);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void clearBatch()
  {
    try
    {
      super.clearBatch();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public int[] executeBatch()
  {
    int[] arrayOfInt = null;
    try
    {
      arrayOfInt = super.executeBatch();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return arrayOfInt;
  }
  
  public Connection getConnection()
  {
    Connection localConnection = null;
    try
    {
      localConnection = super.getConnection();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localConnection;
  }
  
  public boolean getMoreResults(int paramInt)
  {
    boolean bool = false;
    try
    {
      bool = super.getMoreResults();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return bool;
  }
  
  public ResultSet getGeneratedKeys()
  {
    ResultSet localResultSet = null;
    try
    {
      localResultSet = super.getGeneratedKeys();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localResultSet;
  }
  
  public int executeUpdate(String paramString, int paramInt)
  {
    int i = -1;
    try
    {
      i = super.executeUpdate(paramString, paramInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return i;
  }
  
  public int executeUpdate(String paramString, int[] paramArrayOfInt)
  {
    int i = -1;
    try
    {
      i = super.executeUpdate(paramString, paramArrayOfInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return i;
  }
  
  public int executeUpdate(String paramString, String[] paramArrayOfString)
  {
    int i = -1;
    try
    {
      i = super.executeUpdate(paramString, paramArrayOfString);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return i;
  }
  
  public boolean execute(String paramString, int paramInt)
  {
    boolean bool = false;
    try
    {
      bool = super.execute(paramString, paramInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return bool;
  }
  
  public boolean execute(String paramString, int[] paramArrayOfInt)
  {
    boolean bool = false;
    try
    {
      bool = super.execute(paramString, paramArrayOfInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return bool;
  }
  
  public boolean execute(String paramString, String[] paramArrayOfString)
  {
    boolean bool = false;
    try
    {
      bool = super.execute(paramString, paramArrayOfString);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return bool;
  }
  
  public int getResultSetHoldability()
  {
    int i = -1;
    try
    {
      i = super.getResultSetHoldability();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return i;
  }
  
  public boolean isClosed()
  {
    boolean bool = false;
    try
    {
      bool = super.isClosed();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return bool;
  }
  
  public void setPoolable(boolean paramBoolean)
  {
    try
    {
      super.setPoolable(paramBoolean);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public boolean isPoolable()
  {
    boolean bool = false;
    try
    {
      bool = super.isPoolable();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return bool;
  }
  
  public void closeOnCompletion()
  {
    try
    {
      super.closeOnCompletion();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public boolean isCloseOnCompletion()
  {
    boolean bool = false;
    try
    {
      bool = super.isCloseOnCompletion();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return bool;
  }
  
  public <T> T unwrap(Class<T> paramClass)
  {
    Object localObject = null;
    try
    {
      localObject = super.unwrap(paramClass);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localObject;
  }
  
  public boolean isWrapperFor(Class<?> paramClass)
  {
    boolean bool = false;
    try
    {
      bool = super.isWrapperFor(paramClass);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return bool;
  }
  
  public void registerOutParameter(int paramInt1, int paramInt2)
  {
    try
    {
      super.registerOutParameter(paramInt1, paramInt2);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void registerOutParameter(int paramInt1, int paramInt2, int paramInt3)
  {
    try
    {
      super.registerOutParameter(paramInt1, paramInt2, paramInt3);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public boolean wasNull()
  {
    boolean bool = false;
    try
    {
      bool = super.wasNull();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return bool;
  }
  
  public String getString(int paramInt)
  {
    String str = null;
    try
    {
      str = super.getString(paramInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return str;
  }
  
  public boolean getBoolean(int paramInt)
  {
    boolean bool = false;
    try
    {
      bool = super.getBoolean(paramInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return bool;
  }
  
  public byte getByte(int paramInt)
  {
    byte b = 0;
    try
    {
      b = super.getByte(paramInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return b;
  }
  
  public short getShort(int paramInt)
  {
    short s = 0;
    try
    {
      s = super.getShort(paramInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return s;
  }
  
  public int getInt(int paramInt)
  {
    int i = -1;
    try
    {
      i = super.getInt(paramInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return i;
  }
  
  public long getLong(int paramInt)
  {
    long l = -1L;
    try
    {
      l = super.getLong(paramInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return l;
  }
  
  public float getFloat(int paramInt)
  {
    float f = -1.0F;
    try
    {
      f = super.getFloat(paramInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return f;
  }
  
  public double getDouble(int paramInt)
  {
    double d = -1.0D;
    try
    {
      d = super.getDouble(paramInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return d;
  }
  
  public BigDecimal getBigDecimal(int paramInt1, int paramInt2)
  {
    BigDecimal localBigDecimal = null;
    try
    {
      localBigDecimal = super.getBigDecimal(paramInt1, paramInt2);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localBigDecimal;
  }
  
  public byte[] getBytes(int paramInt)
  {
    byte[] arrayOfByte = null;
    try
    {
      arrayOfByte = super.getBytes(paramInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return arrayOfByte;
  }
  
  public Date getDate(int paramInt)
  {
    Date localDate = null;
    try
    {
      localDate = super.getDate(paramInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localDate;
  }
  
  public Time getTime(int paramInt)
  {
    Time localTime = null;
    try
    {
      localTime = super.getTime(paramInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localTime;
  }
  
  public Timestamp getTimestamp(int paramInt)
  {
    Timestamp localTimestamp = null;
    try
    {
      localTimestamp = super.getTimestamp(paramInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localTimestamp;
  }
  
  public Object getObject(int paramInt)
  {
    Object localObject = null;
    try
    {
      localObject = super.getObject(paramInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localObject;
  }
  
  public BigDecimal getBigDecimal(int paramInt)
  {
    BigDecimal localBigDecimal = null;
    try
    {
      localBigDecimal = super.getBigDecimal(paramInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localBigDecimal;
  }
  
  public Object getObject(int paramInt, Map<String, Class<?>> paramMap)
  {
    Object localObject = null;
    try
    {
      localObject = super.getObject(paramInt, paramMap);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localObject;
  }
  
  public Ref getRef(int paramInt)
  {
    Ref localRef = null;
    try
    {
      localRef = super.getRef(paramInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localRef;
  }
  
  public Blob getBlob(int paramInt)
  {
    Blob localBlob = null;
    try
    {
      localBlob = super.getBlob(paramInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localBlob;
  }
  
  public Clob getClob(int paramInt)
  {
    Clob localClob = null;
    try
    {
      localClob = super.getClob(paramInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localClob;
  }
  
  public Array getArray(int paramInt)
  {
    Array localArray = null;
    try
    {
      localArray = super.getArray(paramInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localArray;
  }
  
  public Date getDate(int paramInt, Calendar paramCalendar)
  {
    Date localDate = null;
    try
    {
      localDate = super.getDate(paramInt, paramCalendar);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localDate;
  }
  
  public Time getTime(int paramInt, Calendar paramCalendar)
  {
    Time localTime = null;
    try
    {
      localTime = super.getTime(paramInt, paramCalendar);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localTime;
  }
  
  public Timestamp getTimestamp(int paramInt, Calendar paramCalendar)
  {
    Timestamp localTimestamp = null;
    try
    {
      localTimestamp = super.getTimestamp(paramInt, paramCalendar);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localTimestamp;
  }
  
  public void registerOutParameter(int paramInt1, int paramInt2, String paramString)
  {
    try
    {
      super.registerOutParameter(paramInt1, paramInt2, paramString);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void registerOutParameter(String paramString, int paramInt)
  {
    try
    {
      super.registerOutParameter(paramString, paramInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void registerOutParameter(String paramString, int paramInt1, int paramInt2)
  {
    try
    {
      super.registerOutParameter(paramString, paramInt1, paramInt2);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void registerOutParameter(String paramString1, int paramInt, String paramString2)
  {
    try
    {
      super.registerOutParameter(paramString1, paramInt, paramString2);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public URL getURL(int paramInt)
  {
    URL localURL = null;
    try
    {
      localURL = super.getURL(paramInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localURL;
  }
  
  public void setURL(String paramString, URL paramURL)
  {
    try
    {
      super.setURL(paramString, paramURL);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setNull(String paramString, int paramInt)
  {
    try
    {
      super.setNull(paramString, paramInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setBoolean(String paramString, boolean paramBoolean)
  {
    try
    {
      super.setBoolean(paramString, paramBoolean);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setByte(String paramString, byte paramByte)
  {
    try
    {
      super.setByte(paramString, paramByte);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setShort(String paramString, short paramShort)
  {
    try
    {
      super.setShort(paramString, paramShort);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setInt(String paramString, int paramInt)
  {
    try
    {
      super.setInt(paramString, paramInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setLong(String paramString, long paramLong)
  {
    try
    {
      super.setLong(paramString, paramLong);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setFloat(String paramString, float paramFloat)
  {
    try
    {
      super.setFloat(paramString, paramFloat);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setDouble(String paramString, double paramDouble)
  {
    try
    {
      super.setDouble(paramString, paramDouble);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setBigDecimal(String paramString, BigDecimal paramBigDecimal)
  {
    try
    {
      super.setBigDecimal(paramString, paramBigDecimal);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setString(String paramString1, String paramString2)
  {
    try
    {
      super.setString(paramString1, paramString2);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setBytes(String paramString, byte[] paramArrayOfByte)
  {
    try
    {
      super.setBytes(paramString, paramArrayOfByte);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setDate(String paramString, Date paramDate)
  {
    try
    {
      super.setDate(paramString, paramDate);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setTime(String paramString, Time paramTime)
  {
    try
    {
      super.setTime(paramString, paramTime);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setTimestamp(String paramString, Timestamp paramTimestamp)
  {
    try
    {
      super.setTimestamp(paramString, paramTimestamp);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setAsciiStream(String paramString, InputStream paramInputStream, int paramInt)
  {
    try
    {
      super.setAsciiStream(paramString, paramInputStream, paramInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setBinaryStream(String paramString, InputStream paramInputStream, int paramInt)
  {
    try
    {
      super.setBinaryStream(paramString, paramInputStream, paramInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setObject(String paramString, Object paramObject, int paramInt1, int paramInt2)
  {
    try
    {
      super.setObject(paramString, paramObject, paramInt1, paramInt2);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setObject(String paramString, Object paramObject, int paramInt)
  {
    try
    {
      super.setObject(paramString, paramObject, paramInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setObject(String paramString, Object paramObject)
  {
    try
    {
      super.setObject(paramString, paramObject);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setCharacterStream(String paramString, Reader paramReader, int paramInt)
  {
    try
    {
      super.setCharacterStream(paramString, paramReader, paramInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setDate(String paramString, Date paramDate, Calendar paramCalendar)
  {
    try
    {
      super.setDate(paramString, paramDate, paramCalendar);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setTime(String paramString, Time paramTime, Calendar paramCalendar)
  {
    try
    {
      super.setTime(paramString, paramTime, paramCalendar);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setTimestamp(String paramString, Timestamp paramTimestamp, Calendar paramCalendar)
  {
    try
    {
      super.setTimestamp(paramString, paramTimestamp, paramCalendar);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setNull(String paramString1, int paramInt, String paramString2)
  {
    try
    {
      super.setNull(paramString1, paramInt, paramString2);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public String getString(String paramString)
  {
    String str = null;
    try
    {
      str = super.getString(paramString);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return str;
  }
  
  public boolean getBoolean(String paramString)
  {
    boolean bool = false;
    try
    {
      bool = super.getBoolean(paramString);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return bool;
  }
  
  public byte getByte(String paramString)
  {
    byte b = 0;
    try
    {
      b = super.getByte(paramString);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return b;
  }
  
  public short getShort(String paramString)
  {
    short s = 0;
    try
    {
      s = super.getShort(paramString);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return s;
  }
  
  public int getInt(String paramString)
  {
    int i = -1;
    try
    {
      i = super.getInt(paramString);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return i;
  }
  
  public long getLong(String paramString)
  {
    long l = -1L;
    try
    {
      l = super.getLong(paramString);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return l;
  }
  
  public float getFloat(String paramString)
  {
    float f = -1.0F;
    try
    {
      f = super.getFloat(paramString);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return f;
  }
  
  public double getDouble(String paramString)
  {
    double d = -1.0D;
    try
    {
      d = super.getDouble(paramString);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return d;
  }
  
  public byte[] getBytes(String paramString)
  {
    byte[] arrayOfByte = null;
    try
    {
      arrayOfByte = super.getBytes(paramString);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return arrayOfByte;
  }
  
  public Date getDate(String paramString)
  {
    Date localDate = null;
    try
    {
      localDate = super.getDate(paramString);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localDate;
  }
  
  public Time getTime(String paramString)
  {
    Time localTime = null;
    try
    {
      localTime = super.getTime(paramString);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localTime;
  }
  
  public Timestamp getTimestamp(String paramString)
  {
    Timestamp localTimestamp = null;
    try
    {
      localTimestamp = super.getTimestamp(paramString);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localTimestamp;
  }
  
  public Object getObject(String paramString)
  {
    Object localObject = null;
    try
    {
      localObject = super.getObject(paramString);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localObject;
  }
  
  public BigDecimal getBigDecimal(String paramString)
  {
    BigDecimal localBigDecimal = null;
    try
    {
      localBigDecimal = super.getBigDecimal(paramString);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localBigDecimal;
  }
  
  public Object getObject(String paramString, Map<String, Class<?>> paramMap)
  {
    Object localObject = null;
    try
    {
      localObject = super.getObject(paramString, paramMap);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localObject;
  }
  
  public Ref getRef(String paramString)
  {
    Ref localRef = null;
    try
    {
      localRef = super.getRef(paramString);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localRef;
  }
  
  public Blob getBlob(String paramString)
  {
    Blob localBlob = null;
    try
    {
      localBlob = super.getBlob(paramString);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localBlob;
  }
  
  public Clob getClob(String paramString)
  {
    Clob localClob = null;
    try
    {
      localClob = super.getClob(paramString);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localClob;
  }
  
  public Array getArray(String paramString)
  {
    Array localArray = null;
    try
    {
      localArray = super.getArray(paramString);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localArray;
  }
  
  public Date getDate(String paramString, Calendar paramCalendar)
  {
    Date localDate = null;
    try
    {
      localDate = super.getDate(paramString, paramCalendar);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localDate;
  }
  
  public Time getTime(String paramString, Calendar paramCalendar)
  {
    Time localTime = null;
    try
    {
      localTime = super.getTime(paramString, paramCalendar);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localTime;
  }
  
  public Timestamp getTimestamp(String paramString, Calendar paramCalendar)
  {
    Timestamp localTimestamp = null;
    try
    {
      localTimestamp = super.getTimestamp(paramString, paramCalendar);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localTimestamp;
  }
  
  public URL getURL(String paramString)
  {
    URL localURL = null;
    try
    {
      localURL = super.getURL(paramString);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localURL;
  }
  
  public RowId getRowId(int paramInt)
  {
    RowId localRowId = null;
    try
    {
      localRowId = super.getRowId(paramInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localRowId;
  }
  
  public RowId getRowId(String paramString)
  {
    RowId localRowId = null;
    try
    {
      localRowId = super.getRowId(paramString);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localRowId;
  }
  
  public void setRowId(String paramString, RowId paramRowId)
  {
    try
    {
      super.setRowId(paramString, paramRowId);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setNString(String paramString1, String paramString2)
  {
    try
    {
      super.setNString(paramString1, paramString2);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setNCharacterStream(String paramString, Reader paramReader, long paramLong)
  {
    try
    {
      super.setNCharacterStream(paramString, paramReader, paramLong);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setNClob(String paramString, NClob paramNClob)
  {
    try
    {
      super.setNClob(paramString, paramNClob);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setClob(String paramString, Reader paramReader, long paramLong)
  {
    try
    {
      super.setClob(paramString, paramReader, paramLong);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setBlob(String paramString, InputStream paramInputStream, long paramLong)
  {
    try
    {
      super.setBlob(paramString, paramInputStream, paramLong);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setNClob(String paramString, Reader paramReader, long paramLong)
  {
    try
    {
      super.setNClob(paramString, paramReader, paramLong);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public NClob getNClob(int paramInt)
  {
    NClob localNClob = null;
    try
    {
      localNClob = super.getNClob(paramInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localNClob;
  }
  
  public NClob getNClob(String paramString)
  {
    NClob localNClob = null;
    try
    {
      localNClob = super.getNClob(paramString);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localNClob;
  }
  
  public void setSQLXML(String paramString, SQLXML paramSQLXML)
  {
    try
    {
      super.setSQLXML(paramString, paramSQLXML);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public SQLXML getSQLXML(int paramInt)
  {
    SQLXML localSQLXML = null;
    try
    {
      localSQLXML = super.getSQLXML(paramInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localSQLXML;
  }
  
  public SQLXML getSQLXML(String paramString)
  {
    SQLXML localSQLXML = null;
    try
    {
      localSQLXML = super.getSQLXML(paramString);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localSQLXML;
  }
  
  public String getNString(int paramInt)
  {
    String str = null;
    try
    {
      str = super.getNString(paramInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return str;
  }
  
  public String getNString(String paramString)
  {
    String str = null;
    try
    {
      str = super.getNString(paramString);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return str;
  }
  
  public Reader getNCharacterStream(int paramInt)
  {
    Reader localReader = null;
    try
    {
      localReader = super.getNCharacterStream(paramInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localReader;
  }
  
  public Reader getNCharacterStream(String paramString)
  {
    Reader localReader = null;
    try
    {
      localReader = super.getNCharacterStream(paramString);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localReader;
  }
  
  public Reader getCharacterStream(int paramInt)
  {
    Reader localReader = null;
    try
    {
      localReader = super.getCharacterStream(paramInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localReader;
  }
  
  public Reader getCharacterStream(String paramString)
  {
    Reader localReader = null;
    try
    {
      localReader = super.getCharacterStream(paramString);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localReader;
  }
  
  public void setBlob(String paramString, Blob paramBlob)
  {
    try
    {
      super.setBlob(paramString, paramBlob);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setClob(String paramString, Clob paramClob)
  {
    try
    {
      super.setClob(paramString, paramClob);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setAsciiStream(String paramString, InputStream paramInputStream, long paramLong)
  {
    try
    {
      super.setAsciiStream(paramString, paramInputStream, paramLong);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setBinaryStream(String paramString, InputStream paramInputStream, long paramLong)
  {
    try
    {
      super.setBinaryStream(paramString, paramInputStream, paramLong);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setCharacterStream(String paramString, Reader paramReader, long paramLong)
  {
    try
    {
      super.setCharacterStream(paramString, paramReader, paramLong);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setAsciiStream(String paramString, InputStream paramInputStream)
  {
    try
    {
      super.setAsciiStream(paramString, paramInputStream);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setBinaryStream(String paramString, InputStream paramInputStream)
  {
    try
    {
      super.setBinaryStream(paramString, paramInputStream);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setCharacterStream(String paramString, Reader paramReader)
  {
    try
    {
      super.setCharacterStream(paramString, paramReader);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setNCharacterStream(String paramString, Reader paramReader)
  {
    try
    {
      super.setNCharacterStream(paramString, paramReader);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setClob(String paramString, Reader paramReader)
  {
    try
    {
      super.setClob(paramString, paramReader);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setBlob(String paramString, InputStream paramInputStream)
  {
    try
    {
      super.setBlob(paramString, paramInputStream);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setNClob(String paramString, Reader paramReader)
  {
    try
    {
      super.setNClob(paramString, paramReader);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public <T> T getObject(int paramInt, Class<T> paramClass)
  {
    Object localObject = null;
    try
    {
      localObject = super.getObject(paramInt, paramClass);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localObject;
  }
  
  public <T> T getObject(String paramString, Class<T> paramClass)
  {
    Object localObject = null;
    try
    {
      localObject = super.getObject(paramString, paramClass);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localObject;
  }
}


/* Location:           C:\Users\ibm\Downloads\txc-yun-sample (1)\txc-yun-sample\lib\txc-client-2.0.72.jar
 * Qualified Name:     com.taobao.txc.resourcemanager.b.c.b
 * JD-Core Version:    0.7.0.1
 */